package com.mrhc.android;

import android.text.TextUtils;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * Created by qiaoyanqing on 2019/7/2.
 *
 * @link shelljor@sina.com
 */
public class StringUtil {
    /**
     * 分隔符：逗号
     */
    public static final String SEPARATOR_COMMA = ",";

    private StringUtil() {
    }

    /**
     * 判断一个字符串是否是空白字符串
     * 性能优于String.trim().length()
     *
     * @param str
     * @return 如果字符串为null, 则返回false.
     */
    public static boolean isWitesapceStr(String str) {
        if (null == str) {
            return false;
        }
        boolean result = true;
        for (int index = 0, len = str.length(); index < len; index++) {
            if (!Character.isWhitespace(str.charAt(index))) {
                result = false;
                break;
            }
        }
        return result;
    }

    /**
     * 替换消息中的特殊符号 其他的应该Android可以识别
     * \u0008	\b	Backspace
     * \u0009	\t	Tab	空白
     * \u000A	\n	换行符（换行）	行结束符
     * \u000B	\v	垂直制表符	空白
     * \u000C	\f	换页	空白
     * \u000D	\r	回车	行结束符
     * \u0022	\"	双引号 (")
     * \u0027	\'	单引号 (')
     * \u005C	\\	反斜杠 (\)
     * \u00A0	 	不间断空格	空白
     * \u2028	 	行分隔符	行结束符
     * \u2029	 	段落分隔符	行结束符
     * \uFEFF	 	字节顺序标记	空白
     *
     * @param body
     * @return
     */
    public static String replaceSymbols(String body) {
        body = body.replaceAll("\\u2028", "\n");
        body = body.replaceAll("\\u2029", "\n");
        return body;
    }


    /**
     * 检查对象是否为空
     *
     * @param obj 需要检查的对象
     * @return true：对象为空， false：对象不为空
     */
    public static boolean isEmpty(Object obj) {
        if (obj == null) {
            return true;
        }
        if (obj instanceof String) {
            if (((String) obj).equals("null")) {
                return true;
            }
            if (((String) obj).length() == 0) {
                return true;
            }
        } else if (obj instanceof Map) {
            if (((Map<?, ?>) obj).isEmpty()) {
                return true;
            }
        } else if (obj instanceof Collection) {
            if (((Collection<?>) obj).isEmpty()) {
                return true;
            }
        } else if (obj.getClass().isArray()) {
            if (Arrays.asList(obj).size() == 0) {
                return true;
            }
        }
        return false;
    }

    /**
     * 检查对象是否不为空
     *
     * @param obj 需要检查的对象
     * @return true：对象不为空, false：对象为空
     */
    public static boolean isNoEmpty(Object obj) {
        if (isEmpty(obj)) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * 通过分隔符 将String转成List<Long>
     *
     * @param str  需要转换的String
     * @param sepa 分隔符(为null的话，则使用逗号作为分隔符)
     * @return 成功：返回List<Long>， 失败：返回null
     */
    public static List<Long> str2Longs(String str, String sepa) {
        if (sepa == null) {
            sepa = SEPARATOR_COMMA;
        }
        List<Long> longs = null;
        try {
            if (isNoEmpty(str)) {
                String[] strs = str.split(sepa);
                if (strs != null && strs.length > 0) {
                    longs = new ArrayList<Long>();
                    for (String temps : strs) {
                        longs.add(Long.valueOf(temps));
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            longs = null;
        }
        return longs;
    }


    /**
     * 通过分隔符 将List<Long>转成String
     *
     * @param longs 需要转换的List<Long>
     * @param sepa  分隔符(为null的话，则使用逗号作为分隔符)
     * @return 成功：返回String，失败：返回null
     */
    public static String longs2Str(List<Long> longs, String sepa) {
        if (sepa == null) {
            sepa = SEPARATOR_COMMA;
        }
        String str = null;
        try {
            if (isNoEmpty(longs)) {
                StringBuffer sb = new StringBuffer("");
                for (Long templ : longs) {
                    sb.append(templ);
                    sb.append(sepa);
                }
                str = sb.substring(0, sb.length() - sepa.length());
            }
        } catch (Exception e) {
            e.printStackTrace();
            str = null;
        }
        return str;
    }

    /**
     * 通过分隔符 将String转成List<String>
     *
     * @param str  需要转换的String
     * @param sepa 分隔符(为null的话，则使用逗号作为分隔符)
     * @return 成功：返回List<String>, 失败：返回null
     */
    public static List<String> str2Strs(String str, String sepa) {
        if (sepa == null) {
            sepa = SEPARATOR_COMMA;
        }
        List<String> strs = null;
        if (isNoEmpty(str)) {
            strs = new ArrayList<String>();
            String[] tempArr = str.split(sepa);
            for (String temps : tempArr) {
                strs.add(temps);
            }
        }
        return strs;
    }

    /**
     * 通过分隔符 将List<String>转成String
     *
     * @param strs 需要转换的List<String>
     * @param sepa 分隔符(为null的话，则使用逗号作为分隔符)
     * @return 成功：返回String， 失败：返回null
     */
    public static String strs2Str(List<String> strs, String sepa) {
        if (sepa == null) {
            sepa = SEPARATOR_COMMA;
        }
        String str = null;
        if (isNoEmpty(strs)) {
            StringBuffer sb = new StringBuffer("");
            for (String temps : strs) {
                sb.append(temps);
                sb.append(sepa);
            }
            str = sb.substring(0, sb.length() - sepa.length());
        }
        return str;
    }

    /**
     * 国家码格式化
     *
     * @param country_code
     */
    public static String formatCountryCode(String country_code) {
        //如果国家码为空直接返回空字符
        if (TextUtils.isEmpty(country_code)) {
            return "";
        }

        //过滤+号
        country_code = country_code.replace("+", "");

        DecimalFormat decimalFormat = new DecimalFormat("0000");
        return decimalFormat.format(Integer.valueOf(country_code));
    }

    /**
     * 取两位字符串
     *
     * @param val
     * @param pos
     * @return
     */
    public static String changeStrlength(String val, String pos) {
        String sourStr = val.substring(0, val.indexOf(pos));
        if (sourStr.length() > 1) {
            return sourStr;
        } else {
            return sourStr + "0";
        }
    }

    public static String changeStringsToString(String[] strings, String split) {
        if (TextUtils.isEmpty(split)) {
            split = SEPARATOR_COMMA;
        }
        StringBuilder sb = new StringBuilder("");
        if (strings != null && strings.length > 0) {
            for (String str : strings) {
                sb.append(str);
                sb.append(split);
            }
            sb.delete(sb.length() - split.length(), sb.length());
        }
        return sb.toString();
    }

    public static String[] changeStringToStrings(String str) {
        String[] strings = null;
        if (!TextUtils.isEmpty(str)) {
            strings = str.split(SEPARATOR_COMMA);
        }
        return strings;
    }

    public static Long toLong(String value) {
        try {
            return Long.parseLong(value);
        } catch (Exception e) {
        }

        return 0l;
    }

    public static String e2S(Exception ex) {
        Writer writer = new StringWriter();
        PrintWriter printWriter = new PrintWriter(writer);
        ex.printStackTrace(printWriter);
        Throwable cause = ex.getCause();
        while (cause != null) {
            cause.printStackTrace(printWriter);
            cause = cause.getCause();
        }
        printWriter.close();
        String result = writer.toString();
        return result;
    }

    /**
     * 获取异常的堆栈信息
     *
     * @param t
     * @return
     */
    public static String getStackTrace(Throwable t) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        try {
            t.printStackTrace(pw);
            return sw.toString();
        } finally {
            pw.close();

        }
    }


    /**
     * 去掉字符串所有空格
     *
     * @param key
     */
    public static String removeSpace(String key) {
        if (key == null) {
            return "";
        }
        String newKey = "";
        newKey = key.replaceAll(" ", "");
        return newKey;
    }

    /**
     * 获取字节数
     *
     * @param remark
     * @return
     */
    public static int getBytesLength(String remark) {
        if (isEmpty(remark)) {
            return 0;
        }

        try {
            return new String(remark.getBytes("gb2312"), "iso-8859-1").length();
        } catch (Exception e) {
        }

        return remark.length();
    }

}
